/*
    Promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。
    它们是两个函数，由 JavaScript 引擎提供，不用自己部署。
    resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，
    作为参数传递出去；reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。
    Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。
 */
const promise = new Promise(function (resolve, reject) {
    if (true) {
        resolve('回调成功!');
    } else {
        reject('请求失败');
    }
});

promise.then(function (value) {
    // success
    console.log("success");
}, function (error) {
    // failure
    console.log("false");
});
// Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。
// then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用，
// 第二个回调函数是Promise对象的状态变为rejected时调用。其中，第二个函数是可选的，不一定要提供。这两个函数都接受Promise对象传出的值作为参数。

function timeout(ms) {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, ms, 'done');
    });
}

timeout(100).then((value) => {
    console.log(value);
});

// 上面代码中，Promise 新建后立即执行，所以首先输出的是Promise。
// 然后，then方法指定的回调函数，将在当前脚本所有同步任务执行完才会执行，所以resolved最后输出。
let promise1 = new Promise(function (resolve, reject) {
    //立即执行
    console.log('Promise');
    //通过回调函数执行，then方法
    setInterval(() => {
        let index = Math.random();
        if (index > 0.9) {
            resolve('非常意外');
        } else {
            reject('返回失败');
        }
    }, 1000);

});

promise1.then(success => {
    console.log('成功是回调');
    console.log(success);
}, error => {
    //失败时回调
    console.log('失败时回调');
    console.log(error)
});

console.log('Hi!');

/*
function loadImageAsync(url) {
    return new Promise(function(resolve, reject) {
        const image = new Image();

        image.onload = function() {
            resolve(image);
        };

        image.onerror = function() {
            reject(new Error('Could not load image at ' + url));
        };

        image.src = url;
    });
}*/


/*
const getJSON = function(url) {
    const promise = new Promise(function(resolve, reject){
        const handler = function() {
            if (this.readyState !== 4) {
                return;
            }
            if (this.status === 200) {
                resolve(this.response);
            } else {
                reject(new Error(this.statusText));
            }
        };
        const client = new XMLHttpRequest();
        client.open("GET", url);
        client.onreadystatechange = handler;
        client.responseType = "json";
        client.setRequestHeader("Accept", "application/json");
        client.send();

    });

    return promise;
};

getJSON("/posts.json").then(function(json) {
    console.log('Contents: ' + json);
}, function(error) {
    console.error('出错了', error);
});*/

/*注意，这时p1的状态就会传递给p2，也就是说，p1的状态决定了p2的状态。如果p1的状态是pending，那么p2的回调函数就会等待p1的状态改变；
如果p1的状态已经是resolved或者rejected，那么p2的回调函数将会立刻执行。*/
const ps1 = new Promise(function (resolve, reject) {
    setTimeout(() => reject(new Error('fail')), 3000)
})

const ps2 = new Promise(function (resolve, reject) {
    setTimeout(() => resolve(ps1), 1000)
})

ps2.then(result => console.log(result))
    .catch(error => console.log(error))